import router, { resetRouter, constantRoutes } from '@/router'

// 动态路由组件映射
const componentMap = {
  'LoginPage': () => import('@/components/LoginPage.vue'),
  'ClassDemo': () => import('@/components/ClassDemo.vue'),
  'StudentDemo': () => import('@/components/StudentDemo.vue'),
  'TeacherDemo': () => import('@/components/TeacherDemo.vue'),
  'OperateDemo': () => import('@/components/OperateDemo.vue'),
  'StatisticsDemo': () => import('@/components/StatisticsDemo.vue'),
  'UserDemo': () => import('@/components/UserDemo.vue')
}

const state = {
  // 菜单列表
  menuList: [],
  // 路由列表
  routes: [],
  // 路由是否加载完成
  isRoutesLoaded: false
}

const mutations = {
  SET_MENU_LIST: (state, menus) => {
    state.menuList = menus
  },
  SET_ROUTES: (state, routes) => {
    state.routes = constantRoutes.concat(routes)
  },
  SET_ROUTES_LOADED: (state, status) => {
    state.isRoutesLoaded = status
  }
}

const actions = {
  // 生成路由
  generateRoutes({ commit }, menus) {
    return new Promise((resolve, reject) => {
      try {
        console.log('开始生成动态路由, 原始菜单数据:', JSON.stringify(menus))
        
        // 标记路由为未加载状态
        commit('SET_ROUTES_LOADED', false)
        
        // 确保menus是数组
        if (!Array.isArray(menus)) {
          console.warn('菜单不是数组，强制转换为空数组')
          menus = []
        }
        
        // 如果菜单为空，但用户已登录，添加默认统计路由
        if (menus.length === 0 && localStorage.getItem('isLoggedIn') === 'true') {
          console.warn('菜单为空，添加默认统计路由')
          menus = [{
            id: 1,
            name: 'statistics',
            path: '/statistics',
            component: 'StatisticsDemo',
            icon: 'el-icon-data-analysis',
            title: '统计图表',
            parentId: 0
          }]
        }
        
        // 处理菜单数据，确保路径格式正确
        menus = normalizeMenus(menus)
        console.log('处理后的菜单数据:', JSON.stringify(menus))
        
        // 生成动态路由
        const accessedRoutes = generateAsyncRoutes(menus)
        console.log('生成的动态路由:', JSON.stringify(accessedRoutes.map(r => ({ path: r.path, name: r.name }))))
        
        // 更新路由
        commit('SET_ROUTES', accessedRoutes)
        commit('SET_MENU_LIST', menus)
        
        // 先完全重置路由器
        resetRouter()
        
        // 获取基础路由（常量路由）
        const constantRouteNames = constantRoutes.map(route => route.name).filter(Boolean)
        console.log('常量路由名称:', constantRouteNames)
        
        // 检查添加路由前当前已有的路由路径
        const existingPathsBeforeAdd = router.getRoutes().map(r => r.path)
        console.log('添加路由前的路径:', existingPathsBeforeAdd)
        
        // 添加新路由 - 使用循环添加单个路由
        accessedRoutes.forEach(route => {
          try {
            // 检查路径是否已经存在，避免重复添加
            if (existingPathsBeforeAdd.includes(route.path)) {
              console.warn(`路径 ${route.path} 已存在，跳过添加`)
              return
            }
            
            console.log('尝试添加路由:', route.path)
            router.addRoute(route)
          } catch (err) {
            console.error('添加路由失败:', route.path, err)
          }
        })
        
        // 确保404路由在最后添加
        router.addRoute({
          path: '/:pathMatch(.*)*',
          redirect: '/404',
          hidden: true
        })
        
        // 输出最终的路由表，用于调试
        console.log('最终路由表:', router.getRoutes().map(r => ({ name: r.name, path: r.path })))
        
        // 标记路由为已加载状态
        commit('SET_ROUTES_LOADED', true)
        
        resolve(accessedRoutes)
      } catch (error) {
        console.error('generateRoutes出错:', error)
        commit('SET_ROUTES_LOADED', true) // 即使出错也标记为已加载
        reject(error)
      }
    })
  },
  
  // 重置路由
  resetRoutes({ commit }) {
    commit('SET_ROUTES', [])
    commit('SET_MENU_LIST', [])
    commit('SET_ROUTES_LOADED', false)
    resetRouter()
  }
}

// 规范化菜单数据，确保路径格式正确
function normalizeMenus(menus) {
  if (!Array.isArray(menus)) return []
  
  return menus.map(menu => {
    // 创建新对象，避免修改原对象
    const normalizedMenu = { ...menu }
    
    // 确保路径以/开头
    if (normalizedMenu.path && !normalizedMenu.path.startsWith('/')) {
      normalizedMenu.path = '/' + normalizedMenu.path
    }
    
    // 如果path未定义但name存在，创建path
    if (!normalizedMenu.path && normalizedMenu.name) {
      normalizedMenu.path = '/' + normalizedMenu.name
    }
    
    // 如果name未定义但path存在，创建name
    if (!normalizedMenu.name && normalizedMenu.path) {
      // 移除前导斜杠并使用路径作为名称
      normalizedMenu.name = normalizedMenu.path.replace(/^\//, '')
    }
    
    // 确保component字段存在且有值
    if (!normalizedMenu.component || typeof normalizedMenu.component !== 'string') {
      // 根据path或name推断组件名
      const nameForComponent = normalizedMenu.name || normalizedMenu.path.replace('/', '')
      const firstChar = nameForComponent.charAt(0).toUpperCase()
      const restOfName = nameForComponent.slice(1)
      normalizedMenu.component = firstChar + restOfName + 'Demo'
      console.log(`为菜单[${normalizedMenu.path}]推断组件名:`, normalizedMenu.component)
    }
    
    // 确保title字段存在
    if (!normalizedMenu.title) {
      normalizedMenu.title = normalizedMenu.name || '未命名菜单'
    }
    
    // 确保icon字段存在
    if (!normalizedMenu.icon) {
      normalizedMenu.icon = 'el-icon-menu' // 默认图标
    }
    
    // 递归处理子菜单
    if (normalizedMenu.children && normalizedMenu.children.length > 0) {
      normalizedMenu.children = normalizeMenus(normalizedMenu.children)
    }
    
    return normalizedMenu
  })
}

// 生成动态路由
function generateAsyncRoutes(menus) {
  if (!Array.isArray(menus)) return []
  
  // 记录已使用的路由名称，避免重复
  const usedNames = new Set()
  const timestamp = Date.now() // 使用时间戳确保唯一性
  
  return menus.map(menu => {
    try {
      // 尝试找到对应的组件
      let component
      if (menu.component && componentMap[menu.component]) {
        component = componentMap[menu.component]
      } else if (menu.component && menu.component.endsWith('Demo')) {
        // 尝试从componentMap中查找
        component = componentMap[menu.component]
      }
      
      // 如果仍未找到组件，使用默认组件
      if (!component) {
        console.warn(`找不到组件[${menu.component}]，使用默认StatisticsDemo组件`)
        component = componentMap['StatisticsDemo']
      }
      
      // 确保路由名称唯一
      let routeName = menu.name || menu.path.replace(/^\//, '')
      // 添加时间戳作为后缀确保唯一
      routeName = `${routeName}_${timestamp}_${Math.floor(Math.random() * 1000)}`
      usedNames.add(routeName)
      
      // 创建路由配置
      const route = {
        path: menu.path,
        name: routeName,
        component: component,
        meta: { 
          title: menu.title || menu.name || routeName.split('_')[0],
          icon: menu.icon || 'el-icon-s-tools',
          roles: menu.roles || [],
          originalMenu: menu // 保存原始菜单信息
        }
      }
      
      // 如果有子菜单，递归处理
      if (menu.children && menu.children.length > 0) {
        route.children = generateAsyncRoutes(menu.children)
      }
      
      return route
    } catch (error) {
      console.error('处理菜单项出错:', menu, error)
      // 返回一个默认路由，避免整个路由生成失败
      const fallbackName = `error_${timestamp}_${Math.floor(Math.random() * 1000)}`
      usedNames.add(fallbackName)
      
      return {
        path: menu.path || '/error',
        name: fallbackName,
        component: componentMap['StatisticsDemo'],
        meta: { 
          title: '出错的路由', 
          icon: 'el-icon-warning',
          originalMenu: menu 
        }
      }
    }
  })
}

export default {
  namespaced: true,
  state,
  mutations,
  actions
} 